home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / mint / gcc / gcc261a.zoo / info / gcc.info-23 < prev    next >
Encoding:
GNU Info File  |  1994-10-31  |  23.5 KB  |  553 lines

  1. This is Info file gcc.info, produced by Makeinfo-1.54 from the input
  2. file gcc.texi.
  3.  
  4.    This file documents the use and the internals of the GNU compiler.
  5.  
  6.    Published by the Free Software Foundation 675 Massachusetts Avenue
  7. Cambridge, MA 02139 USA
  8.  
  9.    Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc.
  10.  
  11.    Permission is granted to make and distribute verbatim copies of this
  12. manual provided the copyright notice and this permission notice are
  13. preserved on all copies.
  14.  
  15.    Permission is granted to copy and distribute modified versions of
  16. this manual under the conditions for verbatim copying, provided also
  17. that the sections entitled "GNU General Public License" and "Protect
  18. Your Freedom--Fight `Look And Feel'" are included exactly as in the
  19. original, and provided that the entire resulting derived work is
  20. distributed under the terms of a permission notice identical to this
  21. one.
  22.  
  23.    Permission is granted to copy and distribute translations of this
  24. manual into another language, under the above conditions for modified
  25. versions, except that the sections entitled "GNU General Public
  26. License" and "Protect Your Freedom--Fight `Look And Feel'", and this
  27. permission notice, may be included in translations approved by the Free
  28. Software Foundation instead of in the original English.
  29.  
  30. File: gcc.info,  Node: Misc,  Prev: Cross-compilation,  Up: Target Macros
  31.  
  32. Miscellaneous Parameters
  33. ========================
  34.  
  35. `PREDICATE_CODES'
  36.      Define this if you have defined special-purpose predicates in the
  37.      file `MACHINE.c'.  This macro is called within an initializer of an
  38.      array of structures.  The first field in the structure is the name
  39.      of a predicate and the second field is an array of rtl codes.  For
  40.      each predicate, list all rtl codes that can be in expressions
  41.      matched by the predicate.  The list should have a trailing comma.
  42.      Here is an example of two entries in the list for a typical RISC
  43.      machine:
  44.  
  45.           #define PREDICATE_CODES \
  46.             {"gen_reg_rtx_operand", {SUBREG, REG}},  \
  47.             {"reg_or_short_cint_operand", {SUBREG, REG, CONST_INT}},
  48.  
  49.      Defining this macro does not affect the generated code (however,
  50.      incorrect definitions that omit an rtl code that may be matched by
  51.      the predicate can cause the compiler to malfunction).  Instead, it
  52.      allows the table built by `genrecog' to be more compact and
  53.      efficient, thus speeding up the compiler.  The most important
  54.      predicates to include in the list specified by this macro are
  55.      thoses used in the most insn patterns.
  56.  
  57. `CASE_VECTOR_MODE'
  58.      An alias for a machine mode name.  This is the machine mode that
  59.      elements of a jump-table should have.
  60.  
  61. `CASE_VECTOR_PC_RELATIVE'
  62.      Define this macro if jump-tables should contain relative addresses.
  63.  
  64. `CASE_DROPS_THROUGH'
  65.      Define this if control falls through a `case' insn when the index
  66.      value is out of range.  This means the specified default-label is
  67.      actually ignored by the `case' insn proper.
  68.  
  69. `CASE_VALUES_THRESHOLD'
  70.      Define this to be the smallest number of different values for
  71.      which it is best to use a jump-table instead of a tree of
  72.      conditional branches.  The default is four for machines with a
  73.      `casesi' instruction and five otherwise.  This is best for most
  74.      machines.
  75.  
  76. `WORD_REGISTER_OPERATIONS'
  77.      Define this macro if operations between registers with integral
  78.      mode smaller than a word are always performed on the entire
  79.      register.  Most RISC machines have this property and most CISC
  80.      machines do not.
  81.  
  82. `LOAD_EXTEND_OP (MODE)'
  83.      Define this macro to be a C expression indicating when insns that
  84.      read memory in MODE, an integral mode narrower than a word, set the
  85.      bits outside of MODE to be either the sign-extension or the
  86.      zero-extension of the data read.  Return `SIGN_EXTEND' for values
  87.      of MODE for which the insn sign-extends, `ZERO_EXTEND' for which
  88.      it zero-extends, and `NIL' for other modes.
  89.  
  90.      This macro is not called with MODE non-integral or with a width
  91.      greater than or equal to `BITS_PER_WORD', so you may return any
  92.      value in this case.  Do not define this macro if it would always
  93.      return `NIL'.  On machines where this macro is defined, you will
  94.      normally define it as the constant `SIGN_EXTEND' or `ZERO_EXTEND'.
  95.  
  96. `IMPLICIT_FIX_EXPR'
  97.      An alias for a tree code that should be used by default for
  98.      conversion of floating point values to fixed point.  Normally,
  99.      `FIX_ROUND_EXPR' is used.
  100.  
  101. `FIXUNS_TRUNC_LIKE_FIX_TRUNC'
  102.      Define this macro if the same instructions that convert a floating
  103.      point number to a signed fixed point number also convert validly
  104.      to an unsigned one.
  105.  
  106. `EASY_DIV_EXPR'
  107.      An alias for a tree code that is the easiest kind of division to
  108.      compile code for in the general case.  It may be `TRUNC_DIV_EXPR',
  109.      `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or `ROUND_DIV_EXPR'.  These four
  110.      division operators differ in how they round the result to an
  111.      integer.  `EASY_DIV_EXPR' is used when it is permissible to use
  112.      any of those kinds of division and the choice should be made on
  113.      the basis of efficiency.
  114.  
  115. `MOVE_MAX'
  116.      The maximum number of bytes that a single instruction can move
  117.      quickly from memory to memory.
  118.  
  119. `MAX_MOVE_MAX'
  120.      The maximum number of bytes that a single instruction can move
  121.      quickly from memory to memory.  If this is undefined, the default
  122.      is `MOVE_MAX'.  Otherwise, it is the constant value that is the
  123.      largest value that `MOVE_MAX' can have at run-time.
  124.  
  125. `SHIFT_COUNT_TRUNCATED'
  126.      A C expression that is nonzero if on this machine the number of
  127.      bits actually used for the count of a shift operation is equal to
  128.      the number of bits needed to represent the size of the object
  129.      being shifted.  When this macro is non-zero, the compiler will
  130.      assume that it is safe to omit a sign-extend, zero-extend, and
  131.      certain bitwise `and' instructions that truncates the count of a
  132.      shift operation.  On machines that have instructions that act on
  133.      bitfields at variable positions, which may include `bit test'
  134.      instructions, a nonzero `SHIFT_COUNT_TRUNCATED' also enables
  135.      deletion of truncations of the values that serve as arguments to
  136.      bitfield instructions.
  137.  
  138.      If both types of instructions truncate the count (for shifts) and
  139.      position (for bitfield operations), or if no variable-position
  140.      bitfield instructions exist, you should define this macro.
  141.  
  142.      However, on some machines, such as the 80386 and the 680x0,
  143.      truncation only applies to shift operations and not the (real or
  144.      pretended) bitfield operations.  Define `SHIFT_COUNT_TRUNCATED' to
  145.      be zero on such machines.  Instead, add patterns to the `md' file
  146.      that include the implied truncation of the shift instructions.
  147.  
  148.      You need not define this macro if it would always have the value
  149.      of zero.
  150.  
  151. `TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)'
  152.      A C expression which is nonzero if on this machine it is safe to
  153.      "convert" an integer of INPREC bits to one of OUTPREC bits (where
  154.      OUTPREC is smaller than INPREC) by merely operating on it as if it
  155.      had only OUTPREC bits.
  156.  
  157.      On many machines, this expression can be 1.
  158.  
  159.      When `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for
  160.      modes for which `MODES_TIEABLE_P' is 0, suboptimal code can result.
  161.      If this is the case, making `TRULY_NOOP_TRUNCATION' return 0 in
  162.      such cases may improve things.
  163.  
  164. `STORE_FLAG_VALUE'
  165.      A C expression describing the value returned by a comparison
  166.      operator with an integral mode and stored by a store-flag
  167.      instruction (`sCOND') when the condition is true.  This
  168.      description must apply to *all* the `sCOND' patterns and all the
  169.      comparison operators whose results have a `MODE_INT' mode.
  170.  
  171.      A value of 1 or -1 means that the instruction implementing the
  172.      comparison operator returns exactly 1 or -1 when the comparison is
  173.      true and 0 when the comparison is false.  Otherwise, the value
  174.      indicates which bits of the result are guaranteed to be 1 when the
  175.      comparison is true.  This value is interpreted in the mode of the
  176.      comparison operation, which is given by the mode of the first
  177.      operand in the `sCOND' pattern.  Either the low bit or the sign
  178.      bit of `STORE_FLAG_VALUE' be on.  Presently, only those bits are
  179.      used by the compiler.
  180.  
  181.      If `STORE_FLAG_VALUE' is neither 1 or -1, the compiler will
  182.      generate code that depends only on the specified bits.  It can also
  183.      replace comparison operators with equivalent operations if they
  184.      cause the required bits to be set, even if the remaining bits are
  185.      undefined.  For example, on a machine whose comparison operators
  186.      return an `SImode' value and where `STORE_FLAG_VALUE' is defined as
  187.      `0x80000000', saying that just the sign bit is relevant, the
  188.      expression
  189.  
  190.           (ne:SI (and:SI X (const_int POWER-OF-2)) (const_int 0))
  191.  
  192.      can be converted to
  193.  
  194.           (ashift:SI X (const_int N))
  195.  
  196.      where N is the appropriate shift count to move the bit being
  197.      tested into the sign bit.
  198.  
  199.      There is no way to describe a machine that always sets the
  200.      low-order bit for a true value, but does not guarantee the value
  201.      of any other bits, but we do not know of any machine that has such
  202.      an instruction.  If you are trying to port GNU CC to such a
  203.      machine, include an instruction to perform a logical-and of the
  204.      result with 1 in the pattern for the comparison operators and let
  205.      us know (*note How to Report Bugs: Bug Reporting.).
  206.  
  207.      Often, a machine will have multiple instructions that obtain a
  208.      value from a comparison (or the condition codes).  Here are rules
  209.      to guide the choice of value for `STORE_FLAG_VALUE', and hence the
  210.      instructions to be used:
  211.  
  212.         * Use the shortest sequence that yields a valid definition for
  213.           `STORE_FLAG_VALUE'.  It is more efficient for the compiler to
  214.           "normalize" the value (convert it to, e.g., 1 or 0) than for
  215.           the comparison operators to do so because there may be
  216.           opportunities to combine the normalization with other
  217.           operations.
  218.  
  219.         * For equal-length sequences, use a value of 1 or -1, with -1
  220.           being slightly preferred on machines with expensive jumps and
  221.           1 preferred on other machines.
  222.  
  223.         * As a second choice, choose a value of `0x80000001' if
  224.           instructions exist that set both the sign and low-order bits
  225.           but do not define the others.
  226.  
  227.         * Otherwise, use a value of `0x80000000'.
  228.  
  229.      Many machines can produce both the value chosen for
  230.      `STORE_FLAG_VALUE' and its negation in the same number of
  231.      instructions.  On those machines, you should also define a pattern
  232.      for those cases, e.g., one matching
  233.  
  234.           (set A (neg:M (ne:M B C)))
  235.  
  236.      Some machines can also perform `and' or `plus' operations on
  237.      condition code values with less instructions than the corresponding
  238.      `sCOND' insn followed by `and' or `plus'.  On those machines,
  239.      define the appropriate patterns.  Use the names `incscc' and
  240.      `decscc', respectively, for the the patterns which perform `plus'
  241.      or `minus' operations on condition code values.  See `rs6000.md'
  242.      for some examples.  The GNU Superoptizer can be used to find such
  243.      instruction sequences on other machines.
  244.  
  245.      You need not define `STORE_FLAG_VALUE' if the machine has no
  246.      store-flag instructions.
  247.  
  248. `FLOAT_STORE_FLAG_VALUE'
  249.      A C expression that gives a non-zero floating point value that is
  250.      returned when comparison operators with floating-point results are
  251.      true.  Define this macro on machine that have comparison
  252.      operations that return floating-point values.  If there are no
  253.      such operations, do not define this macro.
  254.  
  255. `Pmode'
  256.      An alias for the machine mode for pointers.  Normally the
  257.      definition can be
  258.  
  259.           #define Pmode SImode
  260.  
  261. `FUNCTION_MODE'
  262.      An alias for the machine mode used for memory references to
  263.      functions being called, in `call' RTL expressions.  On most
  264.      machines this should be `QImode'.
  265.  
  266. `INTEGRATE_THRESHOLD (DECL)'
  267.      A C expression for the maximum number of instructions above which
  268.      the function DECL should not be inlined.  DECL is a
  269.      `FUNCTION_DECL' node.
  270.  
  271.      The default definition of this macro is 64 plus 8 times the number
  272.      of arguments that the function accepts.  Some people think a larger
  273.      threshold should be used on RISC machines.
  274.  
  275. `SCCS_DIRECTIVE'
  276.      Define this if the preprocessor should ignore `#sccs' directives
  277.      and print no error message.
  278.  
  279. `NO_IMPLICIT_EXTERN_C'
  280.      Define this macro if the system header files support C++ as well
  281.      as C.  This macro inhibits the usual method of using system header
  282.      files in C++, which is to pretend that the file's contents are
  283.      enclosed in `extern "C" {...}'.
  284.  
  285. `HANDLE_PRAGMA (STREAM)'
  286.      Define this macro if you want to implement any pragmas.  If
  287.      defined, it should be a C statement to be executed when `#pragma'
  288.      is seen.  The argument STREAM is the stdio input stream from which
  289.      the source text can be read.
  290.  
  291.      It is generally a bad idea to implement new uses of `#pragma'.  The
  292.      only reason to define this macro is for compatibility with other
  293.      compilers that do support `#pragma' for the sake of any user
  294.      programs which already use it.
  295.  
  296. `VALID_MACHINE_ATTRIBUTE (TYPE, ATTRIBUTES, IDENTIFIER)'
  297.      Define this macro if you want to support machine specific
  298.      attributes for types.  If defined, it should be a C statement
  299.      whose value is nonzero if IDENTIFIER is an attribute that is valid
  300.      for TYPE.  The attributes in ATTRIBUTES have previously been
  301.      assigned to TYPE.
  302.  
  303. `COMP_TYPE_ATTRIBUTES (TYPE1, TYPE2)'
  304.      Define this macro if type attributes must be checked for
  305.      compatibility.  If defined, it should be a C statement that
  306.      returns zero if the attributes on TYPE1 and TYPE2 are
  307.      incompatible, one if they are compatible, and two if they are
  308.      nearly compatible (which causes a warning to be generated).
  309.  
  310. `SET_DEFAULT_TYPE_ATTRIBUTES (TYPE)'
  311.      Define this macro if you want to give the newly defined TYPE some
  312.      default attributes.
  313.  
  314. `DOLLARS_IN_IDENTIFIERS'
  315.      Define this macro to control use of the character `$' in identifier
  316.      names.  The value should be 0, 1, or 2.  0 means `$' is not allowed
  317.      by default; 1 means it is allowed by default if `-traditional' is
  318.      used; 2 means it is allowed by default provided `-ansi' is not
  319.      used.  1 is the default; there is no need to define this macro in
  320.      that case.
  321.  
  322. `NO_DOLLAR_IN_LABEL'
  323.      Define this macro if the assembler does not accept the character
  324.      `$' in label names.  By default constructors and destructors in
  325.      G++ have `$' in the identifiers.  If this macro is defined, `.' is
  326.      used instead.
  327.  
  328. `NO_DOT_IN_LABEL'
  329.      Define this macro if the assembler does not accept the character
  330.      `.' in label names.  By default constructors and destructors in G++
  331.      have names that use `.'.  If this macro is defined, these names
  332.      are rewritten to avoid `.'.
  333.  
  334. `DEFAULT_MAIN_RETURN'
  335.      Define this macro if the target system expects every program's
  336.      `main' function to return a standard "success" value by default
  337.      (if no other value is explicitly returned).
  338.  
  339.      The definition should be a C statement (sans semicolon) to
  340.      generate the appropriate rtl instructions.  It is used only when
  341.      compiling the end of `main'.
  342.  
  343. `HAVE_ATEXIT'
  344.      Define this if the target system supports the function `atexit'
  345.      from the ANSI C standard.  If this is not defined, and
  346.      `INIT_SECTION_ASM_OP' is not defined, a default `exit' function
  347.      will be provided to support C++.
  348.  
  349. `EXIT_BODY'
  350.      Define this if your `exit' function needs to do something besides
  351.      calling an external function `_cleanup' before terminating with
  352.      `_exit'.  The `EXIT_BODY' macro is only needed if netiher
  353.      `HAVE_ATEXIT' nor `INIT_SECTION_ASM_OP' are defined.
  354.  
  355. `INSN_SETS_ARE_DELAYED (INSN)'
  356.      Define this macro as a C expression that is nonzero if it is safe
  357.      for the delay slot scheduler to place instructions in the delay
  358.      slot of INSN, even if they appear to use a resource set or
  359.      clobbered in INSN.  INSN is always a `jump_insn' or an `insn'; GNU
  360.      CC knows that every `call_insn' has this behavior.  On machines
  361.      where some `insn' or `jump_insn' is really a function call and
  362.      hence has this behavior, you should define this macro.
  363.  
  364.      You need not define this macro if it would always return zero.
  365.  
  366. `INSN_REFERENCES_ARE_DELAYED (INSN)'
  367.      Define this macro as a C expression that is nonzero if it is safe
  368.      for the delay slot scheduler to place instructions in the delay
  369.      slot of INSN, even if they appear to set or clobber a resource
  370.      referenced in INSN.  INSN is always a `jump_insn' or an `insn'.
  371.      On machines where some `insn' or `jump_insn' is really a function
  372.      call and its operands are registers whose use is actually in the
  373.      subroutine it calls, you should define this macro.  Doing so
  374.      allows the delay slot scheduler to move instructions which copy
  375.      arguments into the argument registers into the delay slot of INSN.
  376.  
  377.      You need not define this macro if it would always return zero.
  378.  
  379. `MACHINE_DEPENDENT_REORG (INSN)'
  380.      In rare cases, correct code generation requires extra machine
  381.      dependent processing between the second jump optimization pass and
  382.      delayed branch scheduling.  On those machines, define this macro
  383.      as a C statement to act on the code starting at INSN.
  384.  
  385. File: gcc.info,  Node: Config,  Next: Index,  Prev: Target Macros,  Up: Top
  386.  
  387. The Configuration File
  388. **********************
  389.  
  390.    The configuration file `xm-MACHINE.h' contains macro definitions
  391. that describe the machine and system on which the compiler is running,
  392. unlike the definitions in `MACHINE.h', which describe the machine for
  393. which the compiler is producing output.  Most of the values in
  394. `xm-MACHINE.h' are actually the same on all machines that GNU CC runs
  395. on, so large parts of all configuration files are identical.  But there
  396. are some macros that vary:
  397.  
  398. `USG'
  399.      Define this macro if the host system is System V.
  400.  
  401. `VMS'
  402.      Define this macro if the host system is VMS.
  403.  
  404. `FAILURE_EXIT_CODE'
  405.      A C expression for the status code to be returned when the compiler
  406.      exits after serious errors.
  407.  
  408. `SUCCESS_EXIT_CODE'
  409.      A C expression for the status code to be returned when the compiler
  410.      exits without serious errors.
  411.  
  412. `HOST_WORDS_BIG_ENDIAN'
  413.      Defined if the host machine stores words of multi-word values in
  414.      big-endian order.  (GNU CC does not depend on the host byte
  415.      ordering within a word.)
  416.  
  417. `HOST_FLOAT_WORDS_BIG_ENDIAN'
  418.      Define this macro to be 1 if the host machine stores `DFmode',
  419.      `XFmode' or `TFmode' floating point numbers in memory with the
  420.      word containing the sign bit at the lowest address; otherwise,
  421.      define it to be zero.
  422.  
  423.      This macro need not be defined if the ordering is the same as for
  424.      multi-word integers.
  425.  
  426. `HOST_FLOAT_FORMAT'
  427.      A numeric code distinguishing the floating point format for the
  428.      host machine.  See `TARGET_FLOAT_FORMAT' in *Note Storage Layout::
  429.      for the alternatives and default.
  430.  
  431. `HOST_BITS_PER_CHAR'
  432.      A C expression for the number of bits in `char' on the host
  433.      machine.
  434.  
  435. `HOST_BITS_PER_SHORT'
  436.      A C expression for the number of bits in `short' on the host
  437.      machine.
  438.  
  439. `HOST_BITS_PER_INT'
  440.      A C expression for the number of bits in `int' on the host machine.
  441.  
  442. `HOST_BITS_PER_LONG'
  443.      A C expression for the number of bits in `long' on the host
  444.      machine.
  445.  
  446. `ONLY_INT_FIELDS'
  447.      Define this macro to indicate that the host compiler only supports
  448.      `int' bit fields, rather than other integral types, including
  449.      `enum', as do most C compilers.
  450.  
  451. `EXECUTABLE_SUFFIX'
  452.      Define this macro if the host system uses a naming convention for
  453.      executable files that involves a common suffix (such as, in some
  454.      systems, `.exe') that must be mentioned explicitly when you run
  455.      the program.
  456.  
  457. `OBSTACK_CHUNK_SIZE'
  458.      A C expression for the size of ordinary obstack chunks.  If you
  459.      don't define this, a usually-reasonable default is used.
  460.  
  461. `OBSTACK_CHUNK_ALLOC'
  462.      The function used to allocate obstack chunks.  If you don't define
  463.      this, `xmalloc' is used.
  464.  
  465. `OBSTACK_CHUNK_FREE'
  466.      The function used to free obstack chunks.  If you don't define
  467.      this, `free' is used.
  468.  
  469. `USE_C_ALLOCA'
  470.      Define this macro to indicate that the compiler is running with the
  471.      `alloca' implemented in C.  This version of `alloca' can be found
  472.      in the file `alloca.c'; to use it, you must also alter the
  473.      `Makefile' variable `ALLOCA'.  (This is done automatically for the
  474.      systems on which we know it is needed.)
  475.  
  476.      If you do define this macro, you should probably do it as follows:
  477.  
  478.           #ifndef __GNUC__
  479.           #define USE_C_ALLOCA
  480.           #else
  481.           #define alloca __builtin_alloca
  482.           #endif
  483.  
  484.      so that when the compiler is compiled with GNU CC it uses the more
  485.      efficient built-in `alloca' function.
  486.  
  487. `FUNCTION_CONVERSION_BUG'
  488.      Define this macro to indicate that the host compiler does not
  489.      properly handle converting a function value to a
  490.      pointer-to-function when it is used in an expression.
  491.  
  492. `HAVE_VPRINTF'
  493.      Define this if the library function `vprintf' is available on your
  494.      system.
  495.  
  496. `MULTIBYTE_CHARS'
  497.      Define this macro to enable support for multibyte characters in the
  498.      input to GNU CC.  This requires that the host system support the
  499.      ANSI C library functions for converting multibyte characters to
  500.      wide characters.
  501.  
  502. `HAVE_PUTENV'
  503.      Define this if the library function `putenv' is available on your
  504.      system.
  505.  
  506. `NO_SYS_SIGLIST'
  507.      Define this if your system *does not* provide the variable
  508.      `sys_siglist'.
  509.  
  510. `DONT_DECLARE_SYS_SIGLIST'
  511.      Define this if your system has the variable `sys_siglist', and
  512.      there is already a declaration of it in the system header files.
  513.  
  514. `USE_PROTOTYPES'
  515.      Define this to be 1 if you know that the host compiler supports
  516.      prototypes, even if it doesn't define __STDC__, or define it to be
  517.      0 if you do not want any prototypes used in compiling GNU CC.  If
  518.      `USE_PROTOTYPES' is not defined, it will be determined
  519.      automatically whether your compiler supports prototypes by
  520.      checking if `__STDC__' is defined.
  521.  
  522. `NO_MD_PROTOTYPES'
  523.      Define this if you wish suppression of prototypes generated from
  524.      the machine description file, but to use other prototypes within
  525.      GNU CC.  If `USE_PROTOTYPES' is defined to be 0, or the host
  526.      compiler does not support prototypes, this macro has no effect.
  527.  
  528. `MD_CALL_PROTOTYPES'
  529.      Define this if you wish to generate prototypes for the `gen_call'
  530.      or `gen_call_value' functions generated from the machine
  531.      description file.  If `USE_PROTOTYPES' is defined to be 0, or the
  532.      host compiler does not support prototypes, or `NO_MD_PROTOTYPES'
  533.      is defined, this macro has no effect.  As soon as all of the
  534.      machine descriptions are modified to have the appropriate number
  535.      of arguments, this macro will be removed.
  536.  
  537.      Some systems do provide this variable, but with a different name
  538.      such as `_sys_siglist'.  On these systems, you can define
  539.      `sys_siglist' as a macro which expands into the name actually
  540.      provided.
  541.  
  542. `NO_STAB_H'
  543.      Define this if your system does not have the include file
  544.      `stab.h'.  If `USG' is defined, `NO_STAB_H' is assumed.
  545.  
  546.    In addition, configuration files for system V define `bcopy',
  547. `bzero' and `bcmp' as aliases.  Some files define `alloca' as a macro
  548. when compiled with GNU CC, in order to take advantage of the benefit of
  549. GNU CC's built-in `alloca'.
  550.  
  551.